# -*- coding: utf-8 -*-
# Create your views here.
from django.http import *
from django.shortcuts import render_to_response
from django.template import *
from eventos.models import *
from core.XMLParser import *
import datetime
from django.contrib import messages
from eventos.grids import *
from django.contrib.auth.decorators import login_required

################################################################################
@login_required
def index(request, mensaje=None):
    return render_to_response('eventos/index.html',{'user_logged_in':request.user.is_authenticated()}, 
        context_instance=RequestContext(request))

################################################################################
@login_required
def mostrar_todos(request):
    return render_to_response('eventos/index.html',
        {'todos': True, 'user_logged_in':request.user.is_authenticated()},
        context_instance=RequestContext(request))

################################################################################
@login_required
def resultados(request,evento_id=None):
    
    evento = Evento.objects.get(pk=evento_id) if evento_id != None else None
    ev = evento.getXMLObjectList() if evento_id != None else None
    participantes = Participacion.objects.filter(evento=evento) if evento_id != None else None
    
    if request.method == 'POST': # If the form has been submitted...
        if 'boton_cancelar' in request.POST:
            return HttpResponseRedirect('../..') # Redirect after POST
        
        #borrar los resultados que hay en participantes
        for part in participantes:
            lista_1 = borrarResultados(part.getXMLObjectList())
            part.xml_resultado = xml_generador(lista_1)
            part.save()
        
        #borrar los resultados que hay en eventos
        lista_2 = borrarResultados(evento.getXMLObjectList())
        evento.xml = xml_generador(lista_2)
        evento.save()
        
        #recorrer todas las categorías hasta encontrar una con resultados
        almacenarResultados(request, evento, participantes)
        
        messages.success(request, "Resultados de '"+evento.nombre+"' almacenados correctamente.")
        
        return HttpResponseRedirect('../..') # Redirect after POST
        

    return render_to_response('eventos/resultados.html',
    {
        'evento':ev,
        'nombre':evento,
        'participantes': participantes,
        'id':evento_id,
        'user_logged_in':request.user.is_authenticated()
    },
    context_instance=RequestContext(request))

################################################################################

def borrarResultados(lista_deportes, id_atleta=None, lista_borrados = False):
    borrados=[]
    for deporte in lista_deportes:
        for disciplina in deporte.disciplinas:
            for categoria in disciplina.categorias:
                if id_atleta == None:
                    borrados += [("Resultado de "+categoria.nombre+": "+str(i)+"; eliminado.") for i in categoria.resultados]
                    categoria.resultados=[]
                else:
                    for res in categoria.resultados:
                        if res.atleta == id_atleta:
                            borrados.append("Resultado de "+categoria.nombre+": "+res.__unicode__()+"; eliminado.")
                            categoria.resultados.remove(res)
    if lista_borrados:
        return lista_deportes,borrados
    return lista_deportes
        
################################################################################

def almacenarResultados(request, evento, participantes):
    #recorrer todas las categorías hasta encontrar una con resultados
    deportes_evento = evento.getXMLObjectList()
    for deporte in deportes_evento:
        for disciplina in deporte.disciplinas:
            for categoria in disciplina.categorias:
                caid = categoria.id
                if (caid+'-cont') in request.POST:
                    cant = int(request.POST[(categoria.id+'-cont')])
                    if cant!=0:
                        #hay resulados de esta categoria
                        #hay que iterar hasta cant para ver cuáles siguen
                        for i in range(1,cant+1):#empiezan en 1 los resultados
                            if (caid+'-'+str(i)+'-0') in request.POST:
                                #sí está el resultado i
                                if request.POST[(caid+'-'+str(i)+'-0')] != '':
                                    # si atleta no es vacío
                                    pk_atleta = request.POST[(caid+'-'+str(i)+'-0')]
                                    posicion = request.POST[(caid+'-'+str(i)+'-1')]
                                    valor = request.POST[(caid+'-'+str(i)+'-2')]
                                    
                                    if posicion == '' or valor == '':
                                        messages.error(request, "Resultado de '%s' en "+categoria.nombre_completo+" ignorado (en blanco)." % (Atleta.objects.get(pk=pk_atleta)).nombre_completo())
                                        continue
                                    
                                    
                                    #crear el XMLResultado
                                    xmlres = XMLResultado(atleta=pk_atleta,posicion=posicion, valor=valor)
                                    
                                    #obtener la participación del atleta que tuvo resultado:
                                    a_temp = Atleta.objects.get(pk=pk_atleta)
                                    part = participantes.get(atleta=a_temp)
                                    #obtener el objeto xml de la participación
                                    deportes_part = part.getXMLObjectList()
                                    
                                    #agregar xmlres a la participación
                                    deportes_part = agregarResultado(xmlres, caid, deportes_part)
                                    #agregar xmlres al evento
                                    deportes_evento = agregarResultado(xmlres, caid, deportes_evento)
                                    #guardar el xml en participación
                                    part.xml_resultado = xml_generador(deportes_part)
                                    part.save()
                                    print 'eventos.almacenarResultados: Guardando en',evento.nombre,a_temp.nombres,xmlres
                                    #guardar el xml en evento
                                    evento.xml = xml_generador(deportes_evento)
                                    evento.save()


def agregarResultado(xmlResultado, categoria_id, lista_deportes):
    for deporte in lista_deportes:
        for disciplina in deporte.disciplinas:
            for categoria in disciplina.categorias:
                if categoria.id == categoria_id:
                    categoria.resultados.append(xmlResultado)
                    return lista_deportes
    print 'no se agregó ningún resultado con',categoria_id
    return lista_deportes

################################################################################
@login_required
def verEvento(request,evento_id=None):

    evento = Evento.objects.get(pk=evento_id) if evento_id != None else None
    ev = evento.getXMLObjectList() if evento_id != None else None
    participantes = Participacion.objects.filter(evento=evento) if evento_id != None else None
    
    return render_to_response('eventos/verEvento.html',
    {
        'evento':ev,
        'nombre':evento.nombre,
        'participantes': participantes,
        'id':evento_id,
        'user_logged_in':request.user.is_authenticated()
    },
    context_instance=RequestContext(request))

################################################################################
@login_required
def editarEvento(request,evento_id=None):
    
    evento = Evento.objects.get(pk=evento_id)if evento_id != None else None
    lista_todos = Deporte.getAllObjects()
    
    #marcar los chequeados para editar
    if evento != None:
        deps = xml_parser(evento.xml)
        lista_todos = set_checked(lista_todos,deps)
        
    
    if request.method == 'POST': # If the form has been submitted...
        
        prefix = '../' if evento_id != None else ''
        
        if 'boton_cancelar' in request.POST:
            return HttpResponseRedirect(prefix + '..') # Redirect after POST
        
        # A form bound to the POST data
        form = FormularioEventos(request.POST, instance = evento) if evento_id != None else FormularioEventos(request.POST)
        
        if form.is_valid(): # All validation rules pass
            xml = request_xml(request,lista_todos)
            evento = form.save(commit=False)
            evento.xml = xml
            evento.save()
            evento.deportes.clear()
            for dep in lista_todos:
                evento.deportes.add(Deporte.objects.get(pk=dep.pk))
            evento.save()
            
            #borrar todos los participantes
            participantes = Participacion.objects.filter(evento=evento)
            for pa in participantes:
                messages.success(request, u'Participación de \'%s\' eliminada.' % pa.atleta.nombre_completo())
                pa.delete()
            
            messages.success(request, "Evento '%s' guardado exitosamente." % evento.nombre)
            
            if 'boton_guardar' in request.POST:
                return HttpResponseRedirect(prefix + '..') # Redirect after POST
                
            elif 'boton_guardar_y_otro' in request.POST:
                return HttpResponseRedirect(prefix + '../crear/') # Redirect after POST
            
            elif 'boton_guardar_y_editar' in request.POST:
                return HttpResponseRedirect(prefix + '../editar/'+str(evento.id)+'/') # Redirect after POST
        else:
            messages.error(request, "Error. Evento no almacenado.")
    else:
        form = FormularioEventos(instance=evento) if evento_id != None else FormularioEventos()# A form bound to the POST data

    return render_to_response('eventos/editar.html', {
        'form': form,
        'lista': lista_todos,
        'evento' : evento,
        'user_logged_in':request.user.is_authenticated()
    },
    context_instance=RequestContext(request))

################################################################################
@login_required
def nuevaInscripcion(request, evento_id):
    evento = Evento.objects.get(pk=evento_id)
    lista = evento.getXMLObjectList()
    nuevo = True
    
    if request.method == 'POST': # If the form has been submitted...
        
        if 'boton_cancelar' in request.POST:
            return HttpResponseRedirect('..') # Redirect after POST
        
        # A form bound to the POST data
        form = FormularioParticipacion(request.POST)
        
        if form.is_valid(): # All validation rules pass
            participante = form.save(commit = False)
            participante.evento = evento
            print 'editarInscripcion: nuevo participante', participante.atleta.nombre_completo()
            print '\tevento:',evento.nombre
            xml,deportes = request_xml(request, lista, get_lista=True)
            valido,errores = validar_atleta(participante.atleta, deportes)
            
            if not valido:
                for err in errores:
                    messages.error(request, err)
                return HttpResponseRedirect('../crear') # Redirect after POST
            
            participante.xml_resultado = xml
            try:
                participante.save()
                #messages.success(request, "Participacion del atleta '"+participante.atleta.nombres+"' creada exitosamente.")
                messages.success(request, u"Participación del atleta '"+participante.atleta.nombre_completo()+"' creada exitosamente.")
            except:
                messages.error(request, "El atleta ya cuenta con una participación.")
                return HttpResponseRedirect('..') # Redirect after POST
            
            if 'boton_guardar' in request.POST:
                return HttpResponseRedirect('..') # Redirect after POST
            elif 'boton_guardar_y_otro' in request.POST:
                return HttpResponseRedirect('../crear/') # Redirect after POST
            elif 'boton_guardar_y_editar' in request.POST:
                return HttpResponseRedirect('../editar/'+str(participante.atleta.id)+'/') # Redirect after POST
        else:
            messages.error(request,"No se seleccionó atleta.")
    else:
        form = FormularioParticipacion()

    return render_to_response('eventos/editarInscripcion.html', {
        'form': form,
        'lista': lista,
        'nuevo' : nuevo,
        'evento':evento,
        'user_logged_in':request.user.is_authenticated()
    },
    context_instance=RequestContext(request))    

################################################################################
@login_required
def verInscripcion(request, evento_id, atleta_id):
    evento = Evento.objects.get(pk=evento_id)
    atleta = Atleta.objects.get(pk = atleta_id)
    part = Participacion.objects.filter(evento = evento_id, atleta = atleta_id)
    deps = part[0].getXMLObjectList()
    
    return render_to_response('eventos/verInscripcion.html', {
        'deportes': deps,
        'atleta' : atleta,
        'evento' : evento,
        'user_logged_in':request.user.is_authenticated()
    },
    context_instance=RequestContext(request))

################################################################################
@login_required
def editarInscripcion(request, evento_id, atleta_id):

    evento = Evento.objects.get(pk=evento_id)
    atleta = Atleta.objects.get(pk = atleta_id)
    
    part = Participacion.objects.filter(evento = evento_id, atleta = atleta_id)
    nuevo = False
    lista = evento.getXMLObjectList()
    deps = part[0].getXMLObjectList()
    lista = set_checked(lista,deps)
    
    if request.method == 'POST': # If the form has been submitted...
        
        if 'boton_cancelar' in request.POST:
            return HttpResponseRedirect('../..') # Redirect after POST
        
        # A form bound to the POST data
        #form = FormularioParticipacion(request.POST,instance = part[0])
        participante = part[0]
        print 'editarInscripcion: participante', participante.atleta.nombre_completo() #debug
        print '\tevento:',evento.nombre #debug
        xml,deportes = request_xml(request, lista, get_lista=True)
        valido,errores = validar_atleta(participante.atleta, deportes)
        
        if not valido:
            for err in errores:
                messages.error(request, err)
            return HttpResponseRedirect('../../editar/'+str(atleta.pk)) # Redirect after POST
        
        ##########################################################
        
        #guardar el xml
        participante.xml_resultado = xml
        participante.save()
        messages.success(request, u"Participación del atleta '"+participante.atleta.nombre_completo()+"' modificada exitosamente.")
        
        #borrar los resultados en el xml del evento
        lista, borrados = borrarResultados(evento.getXMLObjectList(), id_atleta=atleta.pk, lista_borrados=True)
        evento.xml = xml_generador(lista)
        evento.save()
        
        for b in borrados:
            messages.success(request, b)
        
        if 'boton_guardar' in request.POST:
            return HttpResponseRedirect('../..') # Redirect after POST
        elif 'boton_guardar_y_otro' in request.POST:
            return HttpResponseRedirect('../../crear/') # Redirect after POST
        elif 'boton_guardar_y_editar' in request.POST:
            return HttpResponseRedirect('../../editar/'+str(participante.atleta.pk)+'/') # Redirect after POST
        
    else:
        form = FormularioParticipacion(instance = part[0])

    #print "-----",mensaje
    return render_to_response('eventos/editarInscripcion.html', {
        'form': form,
        'lista': lista,
        'atleta': atleta,
        'evento': evento,
        'nuevo' : nuevo,
        'user_logged_in':request.user.is_authenticated()
    },
    context_instance=RequestContext(request))    

################################################################################
@login_required
def participantes(request, evento_id):
    evento = Evento.objects.get(pk=evento_id)
    return render_to_response('eventos/participantes.html', {'evento': evento},
    context_instance=RequestContext(request))

################################################################################
@login_required
def grid_handler(request):
    # handles pagination, sorting and searching
    grid = EventosGrid()
    return HttpResponse(grid.get_json(request), mimetype="application/json")
@login_required
def grid_config(request):
    # build a config suitable to pass to jqgrid constructor   
    grid = EventosGrid()
    return HttpResponse(grid.get_config(), mimetype="application/json")
@login_required
def grid_recientes_handler(request):
    # handles pagination, sorting and searching
    grid = EventosRecientesGrid()
    return HttpResponse(grid.get_json(request), mimetype="application/json")
@login_required
def grid_recientes_config(request):
    # build a config suitable to pass to jqgrid constructor   
    grid = EventosRecientesGrid()
    return HttpResponse(grid.get_config(), mimetype="application/json")
@login_required
def grid_participantes_handler(request, evento_id):
    # handles pagination, sorting and searching
    grid = ParticipantesGrid(evento_id)
    return HttpResponse(grid.get_json(request), mimetype="application/json")
@login_required
def grid_participantes_config(request, evento_id):
    # build a config suitable to pass to jqgrid constructor   
    grid = ParticipantesGrid(evento_id)
    return HttpResponse(grid.get_config(), mimetype="application/json")
